In [1]:
import pickle
import os
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dropout
from tensorflow.keras.layers import LSTM
from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten, Conv3D, MaxPooling1D, Conv1D
from tensorflow.keras.backend import clear_session
from tensorflow.keras.callbacks import EarlyStopping
import tensorflow as tf
from ipynb.fs.full.functions import *
In [2]:
path = os.getcwd()
In [3]:
#carrega os dados em forma de dicionario no qual a chave é o sensor e o valor são as medidas
#12 medias por pessoa
#13 pessoas participantes
#156 (12*13) dados por sensor
#6 sensores e seus respectivos outputs (ps: da forma como os dados estão organizados, o output é o mesmo para todos os sensores)
with open (path+'/rede/pickles_data/all_data_dict.pkl','rb') as all_data:
all_data_dict = pickle.load(all_data)
In [4]:
#separa os dados
dados_sensores_accx = all_data_dict['dados_sensores_accx']
dados_sensores_accy = all_data_dict['dados_sensores_accy']
dados_sensores_accz = all_data_dict['dados_sensores_accz']
dados_sensores_gyrox = all_data_dict['dados_sensores_gyrox']
dados_sensores_gyroy = all_data_dict['dados_sensores_gyroy']
dados_sensores_gyroz = all_data_dict['dados_sensores_gyroz']
lista_pessoas_output_accx = all_data_dict['lista_pessoas_output_accx']
lista_pessoas_output_accy = all_data_dict['lista_pessoas_output_accy']
lista_pessoas_output_accz = all_data_dict['lista_pessoas_output_accz']
lista_pessoas_output_gyrox = all_data_dict['lista_pessoas_output_gyrox']
lista_pessoas_output_gyroy = all_data_dict['lista_pessoas_output_gyroy']
lista_pessoas_output_gyroz = all_data_dict['lista_pessoas_output_gyroz']
Parametros¶
In [5]:
dicionario_pessoas = enumera_dicionario(['Amanda','Anderson','Carlos','Dias','Gustavo','Henrique','Ian','Jessica','Joao','Junior','Moura','Patrick','Yuri'])
In [6]:
pessoa = 5 #pessoa referencia
janela = 400 #quantidade de dados no vetor
passo = 60 # quantidade de dados entre os vetores
In [7]:
#Separa os vetores de dados que entrarão multiplicados no modelo
dados_modelo, output_modelo = elabora_input_rede([dados_sensores_accx, dados_sensores_accy, dados_sensores_accz,
dados_sensores_gyrox, dados_sensores_gyroy, dados_sensores_gyroz],
lista_pessoas_output_accx, pessoa)
In [8]:
#separa os dados em treino e teste, considerando 2/3 para treino
dados_multiplicados_treino = dict()
dados_multiplicados_teste = dict()
for i in dados_modelo:
dados_modelo_treino_X = dados_modelo[i][[0,1,2,3,4,5,6,7,12,13,14,15,16,17,18,19]]
dados_modelo_treino_y = output_modelo[i][[0,1,2,3,4,5,6,7,12,13,14,15,16,17,18,19]]
dados_modelo_teste_X = dados_modelo[i][[8,9,10,11,20,21,22,23]]
dados_modelo_teste_y = output_modelo[i][[8,9,10,11,20,21,22,23]]
dados_modelo_treino_X_multiplicados = multiplica_dados(dados_modelo_treino_X,janela,passo,dados_modelo_treino_y)
dados_modelo_teste_X_multiplicados = multiplica_dados(dados_modelo_teste_X,janela,passo,dados_modelo_teste_y)
dados_multiplicados_treino[i] = dados_modelo_treino_X_multiplicados
dados_multiplicados_teste[i] = dados_modelo_teste_X_multiplicados
In [9]:
#3darray
dados_acelerometro_treino = np.dstack((dados_multiplicados_treino[0][0],dados_multiplicados_treino[1][0],dados_multiplicados_treino[2][0]))
dados_giroscopio_treino = np.dstack((dados_multiplicados_treino[3][0],dados_multiplicados_treino[4][0],dados_multiplicados_treino[5][0]))
dados_acelerometro_giroscopio_treino = np.dstack((dados_multiplicados_treino[0][0],dados_multiplicados_treino[1][0],dados_multiplicados_treino[2][0],dados_multiplicados_treino[3][0],dados_multiplicados_treino[4][0],dados_multiplicados_treino[5][0]))
dados_acelerometro_teste = np.dstack((dados_multiplicados_teste[0][0],dados_multiplicados_teste[1][0],dados_multiplicados_teste[2][0]))
dados_giroscopio_teste = np.dstack((dados_multiplicados_teste[3][0],dados_multiplicados_teste[4][0],dados_multiplicados_teste[5][0]))
dados_acelerometro_giroscopio_teste = np.dstack((dados_multiplicados_teste[0][0],dados_multiplicados_teste[1][0],dados_multiplicados_teste[2][0],dados_multiplicados_teste[3][0],dados_multiplicados_teste[4][0],dados_multiplicados_teste[5][0]))
#o output é o mesmo para qualquer vetor de input
dados_rede_y_treino = dados_multiplicados_treino[0][1]
dados_rede_y_teste = dados_multiplicados_teste[0][1]
REDE LSTM
In [10]:
#Acelerometro
X_train = dados_acelerometro_treino.copy()
y_train = dados_rede_y_treino.copy()
X_val = dados_acelerometro_teste.copy()
y_val = dados_rede_y_teste.copy()
In [11]:
model = Sequential()
model.add(LSTM(40, input_shape = (X_train.shape[1], X_train.shape[2])))
model.add(Dropout(0.2))
model.add(Dense(3000, activation = 'relu'))
model.add(Dense(3000, activation = 'relu'))
model.add(Dense(300, activation = 'relu'))
model.add(Dense(1, activation = 'sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(X_train, y_train, validation_data=[X_val, y_val], epochs=50, batch_size=1024, verbose=True, shuffle=True)
Out[11]:
FFT
In [12]:
ok, errado = valida_dados(dados_sensores_accx)
In [13]:
#Acelerometro
#Treino
train_xAcc = dados_acelerometro_treino.copy()
train_yAcc = dados_rede_y_treino.copy()
#Validação
val_xAcc = dados_acelerometro_teste.copy()
valY = dados_rede_y_teste.copy()
In [14]:
train_x_module = np.sqrt(train_xAcc[:,:,0]**2+train_xAcc[:,:,1]**2+train_xAcc[:,:,2]**2)
print(train_x_module.shape)
train_x_module = train_x_module.reshape((train_x_module.shape[0],train_x_module.shape[1],1))
val_x_module = np.sqrt(val_xAcc[:,:,0]**2+val_xAcc[:,:,1]**2+val_xAcc[:,:,2]**2)
val_x_module = val_x_module.reshape((val_x_module.shape[0],val_x_module.shape[1],1))
print(train_x_module.shape, val_x_module.shape)
In [15]:
model = tf.keras.Sequential()
model.add(Dense (16, activation='relu'))
model.add(Dropout(0.1))
model.add(Dense (16, activation='relu'))
model.add(Dropout(0.1))
model.add(Dense (64, activation='relu'))
model.add(Dropout(0.05))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
In [16]:
fft_train_module = converte_dados_buckets_fft(train_x_module)
fft_test_module = converte_dados_buckets_fft(val_x_module)
In [17]:
model.fit(fft_train_module, y_train, epochs=50, verbose=True, shuffle=True, batch_size=1024, validation_data=(fft_test_module, y_val))
Out[17]:
In [26]:
for i in X_train_concat:
amplitude, frequencia_fft = calculo_fft(i)
p = np.argwhere(frequencia_fft>65)[0][0]
q = np.argwhere(frequencia_fft>0.1)[0][0]
plt.plot(frequencia_fft[q:p],amplitude[q:p])
plt.show()
In [19]:
X_train_concat = np.concatenate((dados_multiplicados_treino[0][0],dados_multiplicados_treino[1][0],dados_multiplicados_treino[2][0]),axis= 1)
X_test_concat = np.concatenate((dados_multiplicados_teste[0][0],dados_multiplicados_teste[1][0],dados_multiplicados_teste[2][0]),axis= 1)
In [20]:
model_fft = tf.keras.Sequential()
model_fft.add(Dense (16, activation='relu'))
model_fft.add(Dropout(0.1))
model_fft.add(Dense (16, activation='relu'))
model_fft.add(Dropout(0.1))
model_fft.add(Dense (64, activation='relu'))
model_fft.add(Dropout(0.05))
model_fft.add(Dense(1, activation='sigmoid'))
model_fft.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
In [21]:
fft_X_train_concat = converte_dados_buckets_fft(X_train_concat)
fft_X_test_concat = converte_dados_buckets_fft(X_test_concat)
In [22]:
model_fft.fit(fft_X_train_concat, y_train, epochs=50, verbose=True, shuffle=True, batch_size=1024, validation_data=(fft_X_test_concat, y_val))
Out[22]:
In [ ]: